Neste laboratório, foram utilizadas as bibliotecas OpenCV2 e MatplotLib, dentro do ambiente de desenvolvimento do Google Colab, para desenvolvimento de atividades introdutórias, relativas ao Processamento Básico de Imagens e Vídeos, utilizando a linguagem Python.
Link para o ambiente Colab utilizado no desenvolvimento desta prática:
Abaixo, temos a importação das bibliotecas utilizadas ao longo do código utilizado nesta prática:
import os
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
from google.colab.patches import cv2_imshow
from IPython.display import HTML
from base64 import b64encode
from google.colab import drive
drive.mount('/content/drive/')
Nesta primeira tarefa, inicialmente foi utilizada a biblioteca MatplotLib para obter algumas das propriedades de cada imagem, como: formato e quantidade de pixels.
Importante Observar que as imagens são computacionalmente representadas na forma matricial (vetores multi-dimensionais).
Além disso, com a mesma biblioteca foi possível plotar as imagens dos integrantes do grupo e seus respectivos avatares, dentro do ambiente do Google Colab, utilizando as funções:
plt.imshow()plt.show()O código utilizado e o resultado obtido, podem ser vistos abaixo:
path_foto = "/content/drive/MyDrive/2021.Q3/COMUNI DIGITAL/lab2/foto_grupo.jpg"
path_avatar = "/content/drive/MyDrive/2021.Q3/COMUNI DIGITAL/lab2/avatar_grupo.jpg"
imagem_foto=plt.imread(path_foto) # Foto Grupo
print("Formato da imagem: ", imagem_foto.shape)
print(f"Esta imagem contém: {imagem_foto.shape[0] * imagem_foto.shape[1]} pixels")
plt.imshow(imagem_foto);
plt.show()
imagem_avatar=plt.imread(path_avatar) # Foto Avatar
print("Formato da imagem: ", imagem_avatar.shape)
print(f"Esta imagem contém: {imagem_avatar.shape[0] * imagem_avatar.shape[1]} pixels")
plt.imshow(imagem_avatar);
plt.show()
Formato da imagem: (1080, 1920, 3) Esta imagem contém: 2073600 pixels
Formato da imagem: (238, 836, 3) Esta imagem contém: 198968 pixels
Após a utilização da biblioteca Matplotlib, foi utilizada a biblioteca OpenCV2 para manipular as imagens originais, transformando a escala de cores RGB tradicional para a escala de tons de cinza.
Nesta parte, foi utilizada a função cv2_imshow, para visualizar o plot das imagens dentro do colab, desta forma, as imagens foram visulizadas com maiores dimensões, preservando a dimensão original de cada imagem.
O código utilizado e o resultado obtido, podem ser vistos abaixo:
print("------------Foto Grupo PB----------\n")
img_gray_foto = cv.imread(path_foto, cv.IMREAD_GRAYSCALE)
cv2_imshow(img_gray_foto)
print("\n------------Avatar PB----------\n")
img_gray_avatar = cv.imread(path_avatar, cv.IMREAD_GRAYSCALE)
cv2_imshow(img_gray_avatar)
------------Foto Grupo PB----------
------------Avatar PB----------
Nesta tarefa, foi utilizada a biblioteca OpenCV2 para manipular as imagens originais, transformando as dimensões (largura e altura) das imagens tanto em escala RGB quanto em tons de cinza.
Nesta parte, foi utilizada a função cv.resize, para redimensionar as imagens originais, utilizando um fator de redução de 50% em relação à dimensão original.
O código utilizado e o resultado obtido, podem ser vistos abaixo:
def resize_normal(img):
img_resized = cv.resize(img, None, fx=0.5, fy=0.5, interpolation = cv.INTER_CUBIC)
img_resized = img_resized[:,:,::-1]
print(img_resized.shape)
return cv2_imshow(img_resized)
def resize_gray(img):
img_resized = cv.resize(img, None, fx=0.5, fy=0.5, interpolation = cv.INTER_CUBIC)
print(img_resized.shape)
return cv2_imshow(img_resized)
print("------------Foto Grupo Resized----------\n")
resize_normal(imagem_foto)
print("\n------------Foto Avatar Resized----------\n")
resize_normal(imagem_avatar)
print("\n------------Foto Grupo PB Resized----------\n")
resize_gray(img_gray_foto)
print("\n------------Foto Avatar PB Resized----------\n")
resize_gray(img_gray_avatar)
------------Foto Grupo Resized---------- (540, 960, 3)
------------Foto Avatar Resized---------- (119, 418, 3)
------------Foto Grupo PB Resized---------- (540, 960)
------------Foto Avatar PB Resized---------- (119, 418)
Podemos notar que a imagem dos avatares, teve sua qualidade mais afetada pela redução de resolução, visto que o exemplar original possuía uma menor resolução, relativamente à imagem dos integrantes do grupo.
Nesta tarefa, inicialmente, foi utilizada a função b64encode().decode(), para decodificar os vídeos originais, de forma a possibilitar sua utilização dentro de um "envelope" HTML.
Envolvendo os vídeos decodificados, dentro deste "envelope", foi possível plotar os vídeos originais dentro do ambiente do Colab e assim, visualizá-los.
O código utilizado e o resultado obtido, podem ser vistos abaixo:
video_slow = "/content/drive/MyDrive/2021.Q3/COMUNI DIGITAL/lab2/movimento_lento.mp4"
video_fast = "/content/drive/MyDrive/2021.Q3/COMUNI DIGITAL/lab2/movimento_rapido.mp4"
mp4 = open(video_slow,'rb').read()
video_decodificado = "data:video/mp4;base64," + b64encode(mp4).decode()
HTML(f'<video controls><source src= {video_decodificado} type="video/mp4"></video>')
mp4 = open(video_fast,'rb').read()
video_decodificado = "data:video/mp4;base64," + b64encode(mp4).decode()
HTML(f'<video controls><source src= {video_decodificado} type="video/mp4"></video>')
Após visualizar os vídeos originais, foi desenvolvida uma função para alterar a resolução dos vídeos, definida como: change_res(input_video,percent,out_name).
Esta função recebe como parâmetros o caminho para o vídeo de entrada (vídeo original), um percentual de redimensionamento e o nome para gravação do arquivo de saída. Como resultado, esta função retorna um envelope HTML, contendo o arquivo de saída para ser visualizado no Colab.
A função foi estruturada da seguinte forma:
Primeiramente, a função obtém os parâmetros dos vídeos originais de dimensão (largura e altura) e multiplica pelo fator de redimensionamento.
Após definir as novas dimensões, utilizamos o método cv.VideoWriter_fourcc, para definir a codificação do vídeo de saída, bem como os demais parâmetros para gravação do vídeo redimensionado.
Após estas definições de gravação, aplica-se o método cv.resize(), para todos os frames do vídeo de entrada e ao final do procedimento, o vídeo redimensionado é gravado num arquivo de saída.
O arquivo de saída é codificado em H.264, para possibilitar sua leitura em ambiente HTML5, utilizando:
os.system("ffmpeg -i output.mp4 -vcodec libx264").
O vídeo redimensionado e devidamente codificado é envolvido em um envelope HTML que é retornado pela função.
O código utilizado e o resultado obtido, podem ser vistos abaixo:
def change_res(input_video,percent,out_name):
cap = cv.VideoCapture(input_video)
width = int(cap.get(3)*percent)
height = int(cap.get(4)*percent)
print(percent*100,"% -",width,"x",height)
fourcc = cv.VideoWriter_fourcc(*"mp4v")
out = cv.VideoWriter('output.mp4',fourcc, cap.get(5), (width,height))
while True:
ret, frame = cap.read()
if ret == True:
b = cv.resize(frame,(width,height),fx=0,fy=0, interpolation = cv.INTER_CUBIC)
out.write(b)
else:
break
cap.release()
out.release()
cv.destroyAllWindows()
os.system("ffmpeg -i output.mp4 -vcodec libx264 "+out_name+".mp4")
os.remove("output.mp4")
mp4 = open(out_name+'.mp4','rb').read()
video_decodificado = "data:video/mp4;base64," + b64encode(mp4).decode()
return HTML(f'<video controls><source src= {video_decodificado} type="video/mp4"></video>')
Abaixo, temos o vídeo lento, redimensionado em 50% e 25% da resolução do vídeo original, respectivamente:
video_slow_50 = change_res(video_slow ,0.5,"output_slow_50")
display(video_slow_50)
video_slow_25 = change_res(video_slow ,0.25,"output_slow_25")
display(video_slow_25)
50.0 % - 424 x 240
25.0 % - 212 x 120
Abaixo, temos o vídeo rápido, redimensionado em 50% e 25% da resolução do vídeo original, respectivamente:
video_fast_50 = change_res(video_fast ,0.5,"output_fast_50")
display(video_fast_50)
video_fast_25 = change_res(video_fast ,0.25,"output_fast_25")
display(video_fast_25)
50.0 % - 320 x 176
25.0 % - 160 x 88
Conforme a realização das etapas descritas no relatório, foi possível aplicar técnicas de programação para processamento de imagens.
As bibliotecas matplotplib e OpenCV atuaram como frameworks aptos à manipulação de dados não estruturados, possibilitando a exploração de características e atributos de Visão Computacional, tais como layers RGB, qualidade e dimensionamento.
Desse modo, foi possível introduzir conceitos de processamento de multimídia que são utilizados em diversas áreas da engenharia, como é o exemplo do Aprendizado de Máquina, com escopo de algoritmos de redes convolucionais capazes de interpretar esse tipo de informação.
HTML(f'<audio controls><source src="https://github.com/gabrielsouza-oss/CSM/blob/main/labs/audio_desc_lab2.mp3?raw=true" type="audio/ogg"></audio>')